package com.example.smartagrisys.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.smartagrisys.common.Result;
import com.example.smartagrisys.constant.OrderStatus;
import com.example.smartagrisys.constant.OrderType;
import com.example.smartagrisys.entity.Order;
import com.example.smartagrisys.entity.Transaction;
import com.example.smartagrisys.entity.User;
import com.example.smartagrisys.service.NotificationService;
import com.example.smartagrisys.service.OrderService;
import com.example.smartagrisys.service.TransactionService;
import com.example.smartagrisys.service.UserService;
import com.example.smartagrisys.util.SecurityUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 订单控制器
 */
@Slf4j
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;
    
    @Autowired
    private TransactionService transactionService;

    @Autowired
    private UserService userService;

    @Autowired
    private NotificationService notificationService;

    /**
     * 分页获取订单列表
     *
     * @param current 当前页
     * @param size 每页条数
     * @param order 查询条件
     * @return 分页结果
     */
    @GetMapping("/page")
    public Result<Page<Order>> getOrderPage(
            @RequestParam(defaultValue = "1") Integer current,
            @RequestParam(defaultValue = "10") Integer size,
            Order order) {
        Page<Order> page = new Page<>(current, size);
        Page<Order> result = orderService.getOrderPage(page, order);
        return Result.success(result);
    }

    /**
     * 获取订单详情
     *
     * @param id 订单ID
     * @return 订单详情
     */
    @GetMapping("/{id}")
    public Result<Order> getOrderById(@PathVariable Long id) {
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        Order order = orderService.getOrderById(id);
        if (order == null) {
            return Result.error("订单不存在");
        }
        
        // 验证是否是自己的订单
        if (!order.getBuyerId().equals(userId) && !order.getSellerId().equals(userId)) {
            return Result.error("无权查看此订单");
        }
        
        return Result.success(order);
    }

    /**
     * 获取我的购买订单
     *
     * @return 订单列表
     */
    @GetMapping("/my/buy")
    public Result<List<Order>> getMyBuyOrders() {
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        List<Order> orders = orderService.getOrdersByBuyerId(userId);
        return Result.success(orders);
    }

    /**
     * 获取我的销售订单
     *
     * @return 订单列表
     */
    @GetMapping("/my/sell")
    public Result<List<Order>> getMySellOrders() {
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        List<Order> orders = orderService.getOrdersBySellerId(userId);
        return Result.success(orders);
    }

    /**
     * 获取农户所有订单（包括购买肥料的订单和销售农产品的订单）
     *
     * @return 订单列表
     */
    @GetMapping("/my/all")
    public Result<List<Order>> getAllMyOrders() {
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        // 检查当前用户是否为农户
        User user = userService.getById(userId);
        if (user == null || !"farmer".equals(user.getRole())) {
            return Result.error("只有农户可以访问此接口");
        }
        
        List<Order> orders = orderService.getAllFarmerOrders(userId);
        return Result.success(orders);
    }

    /**
     * 创建订单
     *
     * @param order 订单信息
     * @return 创建结果
     */
    @PostMapping
    public Result<Order> createOrder(@RequestBody Order order) {
        // 获取当前登录用户
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        log.info("创建订单请求: {}", order);
        
        // 检查必要字段
        if (order.getProductId() == null || order.getQuantity() == null) {
            log.error("订单缺少必要字段 productId: {}, quantity: {}", order.getProductId(), order.getQuantity());
            return Result.error("订单数据不完整");
        }
        
        // 设置买家信息
        User user = userService.getById(userId);
        order.setBuyerId(userId);
        order.setBuyerName(user.getUsername());
        
        // 确保卖家ID已设置
        if (order.getSellerId() == null) {
            log.error("订单缺少sellerId字段");
            return Result.error("订单数据不完整，缺少卖家信息");
        }
        
        // 确保订单类型已正确设置
        if (order.getOrderType() == null) {
            // 默认设置为农产品订单，由服务层进一步验证
            log.info("订单类型未设置，默认为农产品订单");
            order.setOrderType(OrderType.PRODUCT);
        }
        
        // 设置订单状态
        order.setStatus(0); // 待付款
        order.setOrderTime(LocalDateTime.now());
        order.setCreateTime(LocalDateTime.now());
        order.setUpdateTime(LocalDateTime.now());
        
        log.info("处理后订单数据: buyerId={}, sellerId={}, productId={}, orderType={}", 
                order.getBuyerId(), order.getSellerId(), order.getProductId(), order.getOrderType());
        
        boolean result = orderService.createOrder(order);
        if (!result) {
            log.error("创建订单失败");
            return Result.error("创建订单失败");
        }
        
        log.info("订单创建成功, 订单ID: {}, 订单号: {}", order.getId(), order.getOrderNo());
        return Result.success(order);
    }

    /**
     * 支付订单
     *
     * @param id 订单ID
     * @return 支付结果
     */
    @PutMapping("/{id}/pay")
    public Result<Boolean> payOrder(@PathVariable Long id) {
        // 获取当前登录用户
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        // 查询订单
        Order order = orderService.getOrderById(id);
        if (order == null) {
            return Result.error("订单不存在");
        }
        
        // 检查订单是否属于当前用户
        if (!order.getBuyerId().equals(userId)) {
            return Result.error("无权支付此订单");
        }
        
        // 检查订单状态
        if (order.getStatus() != 0) {
            return Result.error("订单状态不正确，无法支付");
        }
        
        // 支付订单
        boolean result = orderService.payOrder(id);
        if (!result) {
            return Result.error("支付失败");
        }
        
        // 为卖家创建收入交易记录
        try {
            Transaction transaction = new Transaction();
            transaction.setUserId(order.getSellerId());
            transaction.setType("income");
            transaction.setOrderNumber(order.getOrderNo());
            transaction.setProductName(order.getProductName());
            transaction.setQuantity(order.getQuantity());
            transaction.setUnit(""); // Order没有单位字段，这里暂时设置为空
            transaction.setAmount(order.getTotalAmount());
            transaction.setTransactionDate(LocalDateTime.now());
            transaction.setNote("销售" + order.getProductName() + "收入");
            transaction.setCreateTime(LocalDateTime.now());
            transaction.setUpdateTime(LocalDateTime.now());
            
            transactionService.createTransaction(transaction);
            log.info("为卖家[{}]创建收入交易记录，订单号: {}, 金额: {}", order.getSellerId(), order.getOrderNo(), order.getTotalAmount());
        } catch (Exception e) {
            log.error("创建卖家收入交易记录失败", e);
            // 不影响主流程，即使交易记录创建失败，订单支付也视为成功
        }
        
        // 为卖家创建订单通知
        try {
            // 获取买家信息
            User buyer = userService.getById(order.getBuyerId());
            if (buyer == null) {
                log.error("买家信息不存在，无法创建订单通知");
            } else {
                // 创建通知内容
                String title = "新订单通知";
                String content = buyer.getUsername() + "已确认订单，请注意发货时间。订单号：" + order.getOrderNo();
                
                // 创建带操作的通知，点击可进入订单详情页
                notificationService.createActionNotification(
                    order.getSellerId(),  // 发送给卖家
                    title,                // 标题
                    content,              // 内容
                    "order",              // 类型为订单
                    "/main/seller/seller-orders",  // 跳转到卖家订单管理页
                    "查看订单",           // 操作按钮文本
                    "primary"             // 操作按钮类型
                );
                
                log.info("为卖家[{}]创建新订单通知，订单号: {}", order.getSellerId(), order.getOrderNo());
            }
        } catch (Exception e) {
            log.error("创建订单通知失败", e);
            // 不影响主流程，即使通知创建失败，订单支付也视为成功
        }
        
        return Result.success(true);
    }

    /**
     * 发货
     *
     * @param id 订单ID
     * @return 发货结果
     */
    @PutMapping("/{id}/ship")
    public Result<Boolean> shipOrder(@PathVariable Long id) {
        // 获取当前登录用户
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        // 验证是否是自己的订单
        Order order = orderService.getOrderById(id);
        if (order == null) {
            return Result.error("订单不存在");
        }
        
        if (!order.getSellerId().equals(userId)) {
            return Result.error("无权操作此订单");
        }
        
        boolean result = orderService.shipOrder(id);
        if (!result) {
            return Result.error("发货失败");
        }
        
        // 为买家创建发货通知
        try {
            // 获取卖家信息
            User seller = userService.getById(order.getSellerId());
            if (seller == null) {
                log.error("卖家信息不存在，无法创建发货通知");
            } else {
                // 创建通知内容
                String title = "订单已发货";
                String content = seller.getUsername() + "已发货，请注意查收。订单号：" + order.getOrderNo() + 
                                "，商品：" + order.getProductName();
                
                // 创建带操作的通知，点击可进入订单详情页
                notificationService.createActionNotification(
                    order.getBuyerId(),  // 发送给买家
                    title,                // 标题
                    content,              // 内容
                    "order",              // 类型为订单
                    "/main/buyer/orders",  // 跳转到买家订单管理页
                    "查看订单",           // 操作按钮文本
                    "primary"             // 操作按钮类型
                );
                
                log.info("为买家[{}]创建发货通知，订单号: {}", order.getBuyerId(), order.getOrderNo());
            }
        } catch (Exception e) {
            log.error("创建发货通知失败", e);
            // 不影响主流程，即使通知创建失败，订单发货也视为成功
        }
        
        return Result.success(true);
    }

    /**
     * 确认收货
     *
     * @param id 订单ID
     * @return 确认结果
     */
    @PutMapping("/{id}/receive")
    public Result<Boolean> receiveOrder(@PathVariable Long id) {
        // 获取当前登录用户
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        // 验证是否是自己的订单
        Order order = orderService.getOrderById(id);
        if (order == null) {
            return Result.error("订单不存在");
        }
        
        if (!order.getBuyerId().equals(userId)) {
            return Result.error("无权操作此订单");
        }
        
        boolean result = orderService.receiveOrder(id);
        if (!result) {
            return Result.error("确认收货失败");
        }
        
        // 为卖家创建收入交易记录（如果在支付时已创建，此处就不再创建）
        try {
            // 检查卖家是否已有此订单的收入记录
            if (!transactionService.existsByOrderNumber(order.getOrderNo())) {
                Transaction transaction = new Transaction();
                transaction.setUserId(order.getSellerId());
                transaction.setType("income");
                transaction.setOrderNumber(order.getOrderNo());
                transaction.setProductName(order.getProductName());
                transaction.setQuantity(order.getQuantity());
                transaction.setUnit(""); // Order没有单位字段，这里暂时设置为空
                transaction.setAmount(order.getTotalAmount());
                transaction.setTransactionDate(LocalDateTime.now());
                transaction.setNote("销售" + order.getProductName() + "收入");
                transaction.setCreateTime(LocalDateTime.now());
                transaction.setUpdateTime(LocalDateTime.now());
                
                transactionService.createTransaction(transaction);
                log.info("为卖家[{}]创建收入交易记录，订单号: {}, 金额: {}", order.getSellerId(), order.getOrderNo(), order.getTotalAmount());
            }
        } catch (Exception e) {
            log.error("创建卖家收入交易记录失败", e);
            // 不影响主流程，即使交易记录创建失败，订单确认收货也视为成功
        }
        
        // 为卖家创建订单完成通知
        try {
            // 获取买家信息
            User buyer = userService.getById(order.getBuyerId());
            if (buyer == null) {
                log.error("买家信息不存在，无法创建订单完成通知");
            } else {
                // 创建通知内容
                String title = "订单已完成";
                String content = buyer.getUsername() + "已确认收货，订单交易已完成。订单号：" + order.getOrderNo() + 
                                "，商品：" + order.getProductName();
                
                // 创建带操作的通知，点击可进入订单详情页
                notificationService.createActionNotification(
                    order.getSellerId(),  // 发送给卖家
                    title,                // 标题
                    content,              // 内容
                    "order",              // 类型为订单
                    "/main/seller/seller-orders",  // 跳转到卖家订单管理页
                    "查看订单",           // 操作按钮文本
                    "success"             // 操作按钮类型为成功样式
                );
                
                log.info("为卖家[{}]创建订单完成通知，订单号: {}", order.getSellerId(), order.getOrderNo());
            }
        } catch (Exception e) {
            log.error("创建订单完成通知失败", e);
            // 不影响主流程，即使通知创建失败，订单确认收货也视为成功
        }
        
        return Result.success(true);
    }

    /**
     * 取消订单
     *
     * @param id 订单ID
     * @return 取消结果
     */
    @PutMapping("/{id}/cancel")
    public Result<Boolean> cancelOrder(@PathVariable Long id) {
        // 获取当前登录用户
        Long userId = SecurityUtil.getCurrentUserId();
        if (userId == null) {
            return Result.error("用户未登录");
        }
        
        // 验证是否是自己的订单
        Order order = orderService.getOrderById(id);
        if (order == null) {
            return Result.error("订单不存在");
        }
        
        if (!order.getBuyerId().equals(userId)) {
            return Result.error("无权操作此订单");
        }
        
        boolean result = orderService.cancelOrder(id);
        if (!result) {
            return Result.error("取消订单失败");
        }
        
        // 为卖家创建订单取消通知
        try {
            // 获取买家信息
            User buyer = userService.getById(order.getBuyerId());
            if (buyer == null) {
                log.error("买家信息不存在，无法创建取消订单通知");
            } else {
                // 创建通知内容
                String title = "订单已取消";
                String content = buyer.getUsername() + "已取消订单。订单号：" + order.getOrderNo() + 
                                "，商品：" + order.getProductName();
                
                // 创建带操作的通知，点击可进入订单详情页
                notificationService.createActionNotification(
                    order.getSellerId(),  // 发送给卖家
                    title,                // 标题
                    content,              // 内容
                    "order",              // 类型为订单
                    "/main/seller/seller-orders",  // 跳转到卖家订单管理页
                    "查看订单",           // 操作按钮文本
                    "warning"             // 操作按钮类型为警告样式
                );
                
                log.info("为卖家[{}]创建订单取消通知，订单号: {}", order.getSellerId(), order.getOrderNo());
            }
        } catch (Exception e) {
            log.error("创建订单取消通知失败", e);
            // 不影响主流程，即使通知创建失败，订单取消也视为成功
        }
        
        return Result.success(true);
    }
} 
